
use crate::metadata::ir::*;
pub(crate) static REGISTERS: IR = IR {
    blocks: &[Block {
        name: "Sdadc",
        extends: None,
        description: Some("Sigma-delta analog-to-digital converter."),
        items: &[
            BlockItem {
                name: "cr1",
                description: Some("control register 1."),
                array: None,
                byte_offset: 0x0,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Cr1"),
                }),
            },
            BlockItem {
                name: "cr2",
                description: Some("control register 2."),
                array: None,
                byte_offset: 0x4,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Cr2"),
                }),
            },
            BlockItem {
                name: "isr",
                description: Some("interrupt and status register."),
                array: None,
                byte_offset: 0x8,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: Some("Isr"),
                }),
            },
            BlockItem {
                name: "clrisr",
                description: Some("interrupt and status clear register."),
                array: None,
                byte_offset: 0xc,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Clrisr"),
                }),
            },
            BlockItem {
                name: "jchgr",
                description: Some("injected channel group selection register."),
                array: None,
                byte_offset: 0x14,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Jchgr"),
                }),
            },
            BlockItem {
                name: "confr",
                description: Some("configuration 0 register."),
                array: Some(Array::Regular(RegularArray { len: 3, stride: 4 })),
                byte_offset: 0x20,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Confr"),
                }),
            },
            BlockItem {
                name: "confchr1",
                description: Some("channel configuration register 1."),
                array: None,
                byte_offset: 0x40,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Confchr1"),
                }),
            },
            BlockItem {
                name: "confchr2",
                description: Some("channel configuration register 2."),
                array: None,
                byte_offset: 0x44,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Confchr2"),
                }),
            },
            BlockItem {
                name: "jdatar",
                description: Some("data register for injected group."),
                array: None,
                byte_offset: 0x60,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: Some("Jdatar"),
                }),
            },
            BlockItem {
                name: "rdatar",
                description: Some("data register for the regular channel."),
                array: None,
                byte_offset: 0x64,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: Some("Rdatar"),
                }),
            },
            BlockItem {
                name: "jdata12r",
                description: Some("SDADC1 and SDADC2 injected data register."),
                array: None,
                byte_offset: 0x70,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: None,
                }),
            },
            BlockItem {
                name: "rdata12r",
                description: Some("SDADC1 and SDADC2 regular data register."),
                array: None,
                byte_offset: 0x74,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: None,
                }),
            },
            BlockItem {
                name: "jdata13r",
                description: Some("SDADC1 and SDADC3 injected data register."),
                array: None,
                byte_offset: 0x78,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: None,
                }),
            },
            BlockItem {
                name: "rdata13r",
                description: Some("SDADC1 and SDADC3 regular data register."),
                array: None,
                byte_offset: 0x7c,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: None,
                }),
            },
        ],
    }],
    fieldsets: &[
        FieldSet {
            name: "Clrisr",
            extends: None,
            description: Some("interrupt and status clear register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "clreocalf",
                    description: Some("Clear the end of calibration flag."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "clrjovrf",
                    description: Some("Clear the injected conversion overrun flag."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "clrrovrf",
                    description: Some("Clear the regular conversion overrun flag."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Confchr1",
            extends: None,
            description: Some("channel configuration register 1."),
            bit_size: 32,
            fields: &[Field {
                name: "confch",
                description: Some("CONFCH0."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 2,
                array: Some(Array::Regular(RegularArray { len: 8, stride: 4 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Confchr2",
            extends: None,
            description: Some("channel configuration register 2."),
            bit_size: 32,
            fields: &[Field {
                name: "confch",
                description: Some("Channel 8 configuration."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 2,
                array: Some(Array::Regular(RegularArray { len: 1, stride: 0 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Confr",
            extends: None,
            description: Some("configuration 0 register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "offset",
                    description: Some("Twelve-bit calibration offset for configuration 0."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 12,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "gain",
                    description: Some("Gain setting for configuration 0."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 20 }),
                    bit_size: 3,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "se",
                    description: Some("Single-ended mode for configuration 0."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 26 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "common",
                    description: Some("Common mode for configuration 0."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 30 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Cr1",
            extends: None,
            description: Some("control register 1."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "eocalie",
                    description: Some("End of calibration interrupt enable."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jeocie",
                    description: Some("Injected end of conversion interrupt enable."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jovrie",
                    description: Some("Injected data overrun interrupt enable."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "reocie",
                    description: Some("Regular end of conversion interrupt enable."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "rovrie",
                    description: Some("Regular data overrun interrupt enable."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "refv",
                    description: Some("Reference voltage selection."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 8 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "slowck",
                    description: Some("Slow clock mode enable."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 10 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "sbi",
                    description: Some("Enter Standby mode when idle."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 11 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "pdi",
                    description: Some("Enter power down mode when idle."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 12 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jsync",
                    description: Some("Launch a injected conversion synchronously with SDADC1."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 14 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "rsync",
                    description: Some("Launch regular conversion synchronously with SDADC1."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 15 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jdmaen",
                    description: Some("DMA channel enabled to read data for the injected channel group."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "rdmaen",
                    description: Some("DMA channel enabled to read data for the regular channel."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 17 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "init",
                    description: Some("Initialization mode request."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 31 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Cr2",
            extends: None,
            description: Some("control register 2."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "adon",
                    description: Some("SDADC enable."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "calibcnt",
                    description: Some(
                        "Number of calibration sequences to be performed (number of valid configurations).",
                    ),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "startcalib",
                    description: Some("Start calibration."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jcont",
                    description: Some("Continuous mode selection for injected conversions."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jds",
                    description: Some("Delay start of injected conversions."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 6 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jextsel",
                    description: Some("Trigger signal selection for launching injected conversions."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 8 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jexten",
                    description: Some("Trigger enable and trigger edge selection for injected conversions."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 13 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jswstart",
                    description: Some("Start a conversion of the injected group of channels."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 15 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "rch",
                    description: Some("Regular channel selection."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "rcont",
                    description: Some("Continuous mode selection for regular conversions."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 22 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "rswstart",
                    description: Some("Software start of a conversion on the regular channel."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 23 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "fast",
                    description: Some("Fast conversion mode selection."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 24 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Isr",
            extends: None,
            description: Some("interrupt and status register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "eocalf",
                    description: Some("End of calibration flag."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jeocf",
                    description: Some("End of injected conversion flag."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jovrf",
                    description: Some("Injected conversion overrun flag."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "reocf",
                    description: Some("End of regular conversion flag."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "rovrf",
                    description: Some("Regular conversion overrun flag."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "calibip",
                    description: Some("Calibration in progress status."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 12 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jcip",
                    description: Some("Injected conversion in progress status."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 13 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "rcip",
                    description: Some("Regular conversion in progress status."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 14 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "stabip",
                    description: Some("Stabilization in progress status."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 15 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "initrdy",
                    description: Some("Initialization mode is ready."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 31 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Jchgr",
            extends: None,
            description: Some("injected channel group selection register."),
            bit_size: 32,
            fields: &[Field {
                name: "jchg",
                description: Some("Injected channel group selection."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 9,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Jdatar",
            extends: None,
            description: Some("data register for injected group."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "jdata",
                    description: Some("Injected group conversion data."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 16,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jdatach",
                    description: Some("Injected channel most recently converted."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 24 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Rdatar",
            extends: None,
            description: Some("data register for the regular channel."),
            bit_size: 32,
            fields: &[Field {
                name: "rdata",
                description: Some("Regular channel conversion data."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 16,
                array: None,
                enumm: None,
            }],
        },
    ],
    enums: &[],
};
